bitkeeper revision 1.1159.170.3 (418fc30fH17ZA9UiJHFIG5IhuuiaCQ)

Rename xen_regs xcs,xds,xes,xfs,xgs,xss to remove the 'x' prefix.

diff --git a/xen/arch/x86/pdb-stub.c b/xen/arch/x86/pdb-stub.c
index 831099e5138246d2507b23cbf683247753dc5074..de1149e7ffacd34de405ea38a7cbe0e41557596b 100644 (file)
--- a/xen/arch/x86/pdb-stub.c
+++ b/xen/arch/x86/pdb-stub.c
@@ -255,17 +255,17 @@ pdb_x86_to_gdb_regs (char *buffer, struct xen_regs *regs)
     idx += sizeof(regs->eip) * 2;
     mem2hex ((char *)&regs->eflags, &buffer[idx], sizeof(regs->eflags));
     idx += sizeof(regs->eflags) * 2;
-    mem2hex ((char *)&regs->xcs, &buffer[idx], sizeof(regs->xcs));
-    idx += sizeof(regs->xcs) * 2;
-    mem2hex ((char *)&regs->xss, &buffer[idx], sizeof(regs->xss));
-    idx += sizeof(regs->xss) * 2;
-    mem2hex ((char *)&regs->xds, &buffer[idx], sizeof(regs->xds));
-    idx += sizeof(regs->xds) * 2;
-    mem2hex ((char *)&regs->xes, &buffer[idx], sizeof(regs->xes));
-    idx += sizeof(regs->xes) * 2;
-    mem2hex ((char *)&regs->xfs, &buffer[idx], sizeof(regs->xfs));
-    idx += sizeof(regs->xfs) * 2;
-    mem2hex ((char *)&regs->xgs, &buffer[idx], sizeof(regs->xgs));
+    mem2hex ((char *)&regs->cs, &buffer[idx], sizeof(regs->cs));
+    idx += sizeof(regs->cs) * 2;
+    mem2hex ((char *)&regs->ss, &buffer[idx], sizeof(regs->ss));
+    idx += sizeof(regs->ss) * 2;
+    mem2hex ((char *)&regs->ds, &buffer[idx], sizeof(regs->ds));
+    idx += sizeof(regs->ds) * 2;
+    mem2hex ((char *)&regs->es, &buffer[idx], sizeof(regs->es));
+    idx += sizeof(regs->es) * 2;
+    mem2hex ((char *)&regs->fs, &buffer[idx], sizeof(regs->fs));
+    idx += sizeof(regs->fs) * 2;
+    mem2hex ((char *)&regs->gs, &buffer[idx], sizeof(regs->gs));
 }
 
 /* at this point we allow any register to be changed, caveat emptor */
@@ -292,17 +292,17 @@ pdb_gdb_to_x86_regs (struct xen_regs *regs, char *buffer)
     buffer += sizeof(regs->eip) * 2;
     hex2mem(buffer, (char *)&regs->eflags, sizeof(regs->eflags));
     buffer += sizeof(regs->eflags) * 2;
-    hex2mem(buffer, (char *)&regs->xcs, sizeof(regs->xcs));
-    buffer += sizeof(regs->xcs) * 2;
-    hex2mem(buffer, (char *)&regs->xss, sizeof(regs->xss));
-    buffer += sizeof(regs->xss) * 2;
-    hex2mem(buffer, (char *)&regs->xds, sizeof(regs->xds));
-    buffer += sizeof(regs->xds) * 2;
-    hex2mem(buffer, (char *)&regs->xes, sizeof(regs->xes));
-    buffer += sizeof(regs->xes) * 2;
-    hex2mem(buffer, (char *)&regs->xfs, sizeof(regs->xfs));
-    buffer += sizeof(regs->xfs) * 2;
-    hex2mem(buffer, (char *)&regs->xgs, sizeof(regs->xgs));
+    hex2mem(buffer, (char *)&regs->cs, sizeof(regs->cs));
+    buffer += sizeof(regs->cs) * 2;
+    hex2mem(buffer, (char *)&regs->ss, sizeof(regs->ss));
+    buffer += sizeof(regs->ss) * 2;
+    hex2mem(buffer, (char *)&regs->ds, sizeof(regs->ds));
+    buffer += sizeof(regs->ds) * 2;
+    hex2mem(buffer, (char *)&regs->es, sizeof(regs->es));
+    buffer += sizeof(regs->es) * 2;
+    hex2mem(buffer, (char *)&regs->fs, sizeof(regs->fs));
+    buffer += sizeof(regs->fs) * 2;
+    hex2mem(buffer, (char *)&regs->gs, sizeof(regs->gs));
 }
 
 int
@@ -1088,11 +1088,11 @@ int pdb_handle_exception(int exceptionVector,
        This occurs when leaving a system call from a domain.
     */
     if ( exceptionVector == 3 &&
-        (xen_regs->xcs & 3) == 3 && 
+        (xen_regs->cs & 3) == 3 && 
         xen_regs->eip != pdb_system_call_next_addr + 1)
     {
         TRC(printf("pdb: user bkpt (0x%x) at 0x%x:0x%lx:0x%lx\n", 
-                  exceptionVector, xen_regs->xcs & 3, cr3, xen_regs->eip));
+                  exceptionVector, xen_regs->cs & 3, cr3, xen_regs->eip));
        return 1;
     }
 

diff --git a/xen/arch/x86/traps.c b/xen/arch/x86/traps.c
index 3f7793c36ebf68050284146f6d3df3348b2af512..b15939d6cfa789fc77649e9b5740af96428b00a6 100644 (file)
--- a/xen/arch/x86/traps.c
+++ b/xen/arch/x86/traps.c
@@ -168,14 +168,14 @@ void show_registers(struct xen_regs *regs)
     unsigned long esp;
     unsigned short ss, ds, es, fs, gs;
 
-    if ( regs->xcs & 3 )
+    if ( regs->cs & 3 )
     {
         esp = regs->esp;
-        ss  = regs->xss & 0xffff;
-        ds  = regs->xds & 0xffff;
-        es  = regs->xes & 0xffff;
-        fs  = regs->xfs & 0xffff;
-        gs  = regs->xgs & 0xffff;
+        ss  = regs->ss & 0xffff;
+        ds  = regs->ds & 0xffff;
+        es  = regs->es & 0xffff;
+        fs  = regs->fs & 0xffff;
+        gs  = regs->gs & 0xffff;
     }
     else
     {
@@ -188,7 +188,7 @@ void show_registers(struct xen_regs *regs)
     }
 
     printk("CPU:    %d\nEIP:    %04x:[<%08lx>]      \nEFLAGS: %08lx\n",
-           smp_processor_id(), 0xffff & regs->xcs, regs->eip, regs->eflags);
+           smp_processor_id(), 0xffff & regs->cs, regs->eip, regs->eflags);
     printk("eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
            regs->eax, regs->ebx, regs->ecx, regs->edx);
     printk("esi: %08lx   edi: %08lx   ebp: %08lx   esp: %08lx\n",
@@ -222,7 +222,7 @@ static inline void do_trap(int trapnr, char *str,
     trap_info_t *ti;
     unsigned long fixup;
 
-    if (!(regs->xcs & 3))
+    if (!(regs->cs & 3))
         goto xen_fault;
 
     ti = current->thread.traps + trapnr;
@@ -285,9 +285,9 @@ asmlinkage void do_int3(struct xen_regs *regs, long error_code)
         return;
 #endif
 
-    if ( (regs->xcs & 3) != 3 )
+    if ( (regs->cs & 3) != 3 )
     {
-        if ( unlikely((regs->xcs & 3) == 0) )
+        if ( unlikely((regs->cs & 3) == 0) )
         {
             show_registers(regs);
             panic("CPU%d FATAL TRAP: vector = 3 (Int3)\n"
@@ -382,7 +382,7 @@ asmlinkage void do_page_fault(struct xen_regs *regs, long error_code)
             return; /* successfully copied the mapping */
     }
 
-    if ( unlikely(!(regs->xcs & 3)) )
+    if ( unlikely(!(regs->cs & 3)) )
         goto xen_fault;
 
     ti = d->thread.traps + 14;
@@ -449,7 +449,7 @@ asmlinkage void do_general_protection(struct xen_regs *regs, long error_code)
     unsigned long fixup;
 
     /* Badness if error in ring 0, or result of an interrupt. */
-    if ( !(regs->xcs & 3) || (error_code & 1) )
+    if ( !(regs->cs & 3) || (error_code & 1) )
         goto gp_in_kernel;
 
     /*
@@ -476,7 +476,7 @@ asmlinkage void do_general_protection(struct xen_regs *regs, long error_code)
     {
         /* This fault must be due to <INT n> instruction. */
         ti = current->thread.traps + (error_code>>3);
-        if ( TI_GET_DPL(ti) >= (regs->xcs & 3) )
+        if ( TI_GET_DPL(ti) >= (regs->cs & 3) )
         {
 #ifdef XEN_DEBUGGER
             if ( pdb_initialized && (pdb_ctx.system_call != 0) )
@@ -662,7 +662,7 @@ asmlinkage void do_debug(struct xen_regs *regs, long error_code)
         return;
     }
 
-    if ( (regs->xcs & 3) == 0 )
+    if ( (regs->cs & 3) == 0 )
     {
         /* Clear TF just for absolute sanity. */
         regs->eflags &= ~EF_TF;

diff --git a/xen/arch/x86/x86_32/seg_fixup.c b/xen/arch/x86/x86_32/seg_fixup.c
index 30ee3222a5ef03aceb8ebb07578881d4ea7e1946..6e705fc04465fa7a5bb08d14f5a5e6c3142b8bed 100644 (file)
--- a/xen/arch/x86/x86_32/seg_fixup.c
+++ b/xen/arch/x86/x86_32/seg_fixup.c
@@ -297,15 +297,15 @@ int gpf_emulate_4gb(struct xen_regs *regs)
     unsigned int  *pseg = NULL; /* segment for memory operand (NULL=default) */
 
     /* WARNING: We only work for ring-3 segments. */
-    if ( unlikely((regs->xcs & 3) != 3) )
+    if ( unlikely((regs->cs & 3) != 3) )
     {
-        DPRINTK("Taken fault at bad CS %04x\n", regs->xcs);
+        DPRINTK("Taken fault at bad CS %04x\n", regs->cs);
         goto fail;
     }
 
-    if ( !linearise_address((u16)regs->xcs, regs->eip, (unsigned long *)&eip) )
+    if ( !linearise_address((u16)regs->cs, regs->eip, (unsigned long *)&eip) )
     {
-        DPRINTK("Cannot linearise %04x:%08lx\n", regs->xcs, regs->eip);
+        DPRINTK("Cannot linearise %04x:%08lx\n", regs->cs, regs->eip);
         goto fail;
     }
 
@@ -332,22 +332,22 @@ int gpf_emulate_4gb(struct xen_regs *regs)
         case 0x66: /* Operand-size override */
             break;
         case 0x2e: /* CS override */
-            pseg = &regs->xcs;
+            pseg = &regs->cs;
             break;
         case 0x3e: /* DS override */
-            pseg = &regs->xds;
+            pseg = &regs->ds;
             break;
         case 0x26: /* ES override */
-            pseg = &regs->xes;
+            pseg = &regs->es;
             break;
         case 0x64: /* FS override */
-            pseg = &regs->xfs;
+            pseg = &regs->fs;
             break;
         case 0x65: /* GS override */
-            pseg = &regs->xgs;
+            pseg = &regs->gs;
             break;
         case 0x36: /* SS override */
-            pseg = &regs->xss;
+            pseg = &regs->ss;
             break;
         default: /* Not a prefix byte */
             goto done_prefix;
@@ -409,7 +409,7 @@ int gpf_emulate_4gb(struct xen_regs *regs)
     {
     case 0:
         if ( pseg == NULL )
-            pseg = &regs->xds;
+            pseg = &regs->ds;
         disp32 = 0;
         if ( rm == 5 ) /* disp32 rather than (EBP) */
         {
@@ -425,7 +425,7 @@ int gpf_emulate_4gb(struct xen_regs *regs)
 
     case 1:
         if ( pseg == NULL ) /* NB. EBP defaults to SS */
-            pseg = (rm == 5) ? &regs->xss : &regs->xds;
+            pseg = (rm == 5) ? &regs->ss : &regs->ds;
         if ( get_user(disp8, pb) )
         {
             DPRINTK("Fault while extracting <disp8>.\n");
@@ -437,7 +437,7 @@ int gpf_emulate_4gb(struct xen_regs *regs)
 
     case 2:
         if ( pseg == NULL ) /* NB. EBP defaults to SS */
-            pseg = (rm == 5) ? &regs->xss : &regs->xds;
+            pseg = (rm == 5) ? &regs->ss : &regs->ds;
         if ( get_user(disp32, (u32 *)pb) )
         {
             DPRINTK("Fault while extracting <disp8>.\n");
@@ -482,7 +482,7 @@ int gpf_emulate_4gb(struct xen_regs *regs)
             "caused GPF(0) at %04x:%08lx\n",
             eip[0], eip[1], eip[2], eip[3],
             eip[4], eip[5], eip[6], eip[7],
-            regs->xcs, regs->eip);
+            regs->cs, regs->eip);
  fail:
     return 0;
 }

diff --git a/xen/include/asm-x86/x86_32/regs.h b/xen/include/asm-x86/x86_32/regs.h
index 9adeb9d42024ff4d15a7ad87c4aed4340c0ddadc..93641bd95ee76760abc3d6b32abd11f712483fe2 100644 (file)
--- a/xen/include/asm-x86/x86_32/regs.h
+++ b/xen/include/asm-x86/x86_32/regs.h
@@ -13,16 +13,16 @@ struct xen_regs
     long eax;
     long orig_eax;
     long eip;
-    int  xcs;
+    int  cs;
     long eflags;
 
     /* Only saved guest activations contain the following fields. */
     long esp;
-    int  xss;
-    int  xes;
-    int  xds;
-    int  xfs;
-    int  xgs;
+    int  ss;
+    int  es;
+    int  ds;
+    int  fs;
+    int  gs;
 };
 
 enum EFLAGS {